﻿package mortal.game.proxy
{
    import Framework.Util.*;
    import Message.DB.Tables.*;
    import Message.Game.*;
    import Message.Public.*;
    import extend.language.*;
    import flash.geom.*;
    import flash.utils.*;
    import mortal.common.error.*;
    import mortal.common.net.*;
    import mortal.component.gconst.*;
    import mortal.game.cache.*;
    import mortal.game.control.*;
    import mortal.game.manager.*;
    import mortal.game.manager.msgTip.*;
    import mortal.game.mvc.*;
    import mortal.game.net.rmi.*;
    import mortal.game.resource.info.item.*;
    import mortal.game.resource.tableConfig.*;
    import mortal.game.scene3D.ai.*;
    import mortal.game.view.common.display.*;
    import mortal.game.view.common.item.*;
    import mortal.game.view.copy.escort.vo.*;
    import mortal.game.view.copy.groupCopy.data.*;
    import mortal.game.view.copy.petBreak.vo.*;
    import mortal.mvc.core.*;

    public class CopyProxy extends Proxy
    {
        private var _copyCode:int;
        private var _frInfoCode:int;
        private var _getRwCode:int;
        private var _getRwLevel:int;

        public function CopyProxy()
        {
            return;
        }// end function

        public function enterCopy(param1:int) : void
        {
            this._copyCode = param1;
            GameRMI.instance.iCopy.enterCopy_async(new AMI_ICopy_enterCopy(null, this.enterFail), param1);
            return;
        }// end function

        private function enterFail(param1:Exception) : void
        {
            var _loc_2:* = param1.message;
            if (!_loc_2)
            {
                _loc_2 = ErrorCode.getErrorStringByCode(param1.code);
            }
            MsgManager.showMouseMsg(_loc_2, MsgRollTipsType.msgRollTips1);
            NetDispatcher.dispatchCmd(ServerCommand.CopyEnterCopyFail, this._copyCode);
            return;
        }// end function

        public function enterCrossServerMap(param1:int) : void
        {
            GameRMI.instance.iCopy.enterCrossMap_async(new AMI_ICopy_enterCrossMap(), param1);
            return;
        }// end function

        public function enterLocalHoleCopy(param1:int) : void
        {
            GameRMI.instance.iCopy.enterLocalHoleCopy_async(new AMI_ICopy_enterLocalHoleCopy(), param1);
            return;
        }// end function

        public function leaveCopy() : void
        {
            GameRMI.instance.iCopy.leftCopy_async(new AMI_ICopy_leftCopy());
            return;
        }// end function

        public function getCopyFirstBlood(param1:int, param2:BaseItem) : void
        {
            GameRMI.instance.iCopy.getCopyFirstBloodReward_async(new AMI_ICopy_getCopyFirstBloodReward(this.getSuccess, null, param2), param1);
            return;
        }// end function

        private function getSuccess(param1:AMI_ICopy_getCopyFirstBloodReward) : void
        {
            var _loc_3:Point = null;
            var _loc_2:* = param1.userObject as BaseItem;
            if (_loc_2)
            {
                _loc_3 = _loc_2.localToGlobal(GameConst.yellowPoint);
                FlyToNavbarTool.flyBitmapOriginalToPack(_loc_2.bitmapdata, _loc_3);
            }
            return;
        }// end function

        public function getGroupCopyTeamInfos(param1:int) : void
        {
            GameRMI.instance.iCopy.getCopyWaitingRoomInfo_async(new AMI_ICopy_getCopyWaitingRoomInfo(), param1);
            return;
        }// end function

        public function copyGroupOperate(param1:int, param2:int, param3:int = 0) : void
        {
            GameRMI.instance.iCopy.copyWaitingRoomOper_async(new AMI_ICopy_copyWaitingRoomOper(this.groupOperSuccess, null, param2), param1, param2, param3);
            return;
        }// end function

        private function groupOperSuccess(param1:AMI_ICopy_copyWaitingRoomOper) : void
        {
            var e:* = param1;
            if (e.userObject == ECopyWaitingOperate._ECopyWaitingQuickGroup)
            {
                var closeGroupwin:* = function () : void
            {
                if (GameController.copy.groupCopy.isViewShow)
                {
                    GameController.copy.groupCopy.view.hide();
                }
                return;
            }// end function
            ;
                CallLater.setCallLater(closeGroupwin, 0.3);
            }
            return;
        }// end function

        public function enterGuildManor(param1:int) : void
        {
            var enterGuildSuccess:Function;
            var guild:* = param1;
            enterGuildSuccess = function (param1:Object) : void
            {
                Cache.instance.guild.curInsideGuildId = guild;
                return;
            }// end function
            ;
            GameRMI.instance.iCopy.enterGuildManor_async(new AMI_ICopy_enterGuildManor(enterGuildSuccess), guild);
            return;
        }// end function

        public function escortOper(param1:EscortCopyOperVo) : void
        {
            var escortOperSuccess:Function;
            var value:* = param1;
            escortOperSuccess = function (param1:AMI_ICopy_escortOper) : void
            {
                if (value.oper == EEscortOper._EEscortOperGetEscort)
                {
                    cache.copy.escort.notCanMove = false;
                    cache.copy.escort.hasGetEscortTask = true;
                }
                else if (value.oper == EEscortOper._EEscortOperRefresh)
                {
                    MsgManager.showRollTipsMsg(Language.getString(70081));
                }
                return;
            }// end function
            ;
            rmi.iCopy.escortOper_async(new AMI_ICopy_escortOper(escortOperSuccess), value.oper, value.extend, value.autoBuy, value.entityId);
            return;
        }// end function

        public function enterGuildCopy() : void
        {
            rmi.iCopy.enterGuildBossCopy_async(new AMI_ICopy_enterGuildBossCopy());
            return;
        }// end function

        public function enterChallengeCopy(param1:int, param2:int, param3:int) : void
        {
            var _loc_4:* = new Object();
            _loc_4.floor = param1;
            _loc_4.level = param2;
            _loc_4.dif = param3;
            rmi.iCopy.enterChallengeCopy_async(new AMI_ICopy_enterChallengeCopy(this.enterSuccess, null, _loc_4), param1, param2, param3);
            return;
        }// end function

        private function enterSuccess(param1:AMI_ICopy_enterChallengeCopy) : void
        {
            var _loc_2:* = param1.userObject.floor;
            var _loc_3:* = param1.userObject.level;
            var _loc_4:* = param1.userObject.dif;
            var _loc_5:* = ChallengeCopyConfig.instance.challengCopyDic[_loc_2][_loc_3][_loc_4];
            var _loc_6:* = new SChallengeCopyTotalTime();
            _loc_6.floor = _loc_2;
            _loc_6.level = _loc_3;
            _loc_6.diff = _loc_4;
            _loc_6.totaltime = _loc_5.reqTime;
            NetDispatcher.dispatchCmd(ServerCommand.ChalengePanelShow, _loc_6);
            return;
        }// end function

        public function clearChallengeCopyCD(param1:int, param2:int) : void
        {
            rmi.iCopy.clearEnterCopyCd_async(new AMI_ICopy_clearEnterCopyCd(this.clearSuccess, null), param1, param2);
            return;
        }// end function

        private function clearSuccess(param1:AMI_ICopy_clearEnterCopyCd) : void
        {
            Cache.instance.copy.challengCopy.residuettimes = 0;
            NetDispatcher.dispatchCmd(ServerCommand.ChallengeClearCDSuccess, null);
            return;
        }// end function

        public function getPlayerChallengeCopyInfo() : void
        {
            rmi.iCopy.getPlayerChallengeCopyInfo_async(new AMI_ICopy_getPlayerChallengeCopyInfo());
            return;
        }// end function

        public function getPlayerChallengeRecord(param1:int, param2:int, param3:int) : void
        {
            rmi.iCopy.getPlayerChallengeRecords_async(new AMI_ICopy_getPlayerChallengeRecords(this.getRecordSuccess), param1, param2, param3);
            return;
        }// end function

        private function getRecordSuccess(param1:AMI_ICopy_getPlayerChallengeRecords, param2:SChallengeCopyRecords) : void
        {
            NetDispatcher.dispatchCmd(ServerCommand.ChallengeUpdateRecord, param2);
            return;
        }// end function

        public function mopChallengeCopy(param1:int, param2:int) : void
        {
            rmi.iCopy.mopChallengeCopy_async(new AMI_ICopy_mopChallengeCopy(this.mopSuccess, null, param1), param1, param2);
            return;
        }// end function

        private function mopSuccess(param1:AMI_ICopy_mopChallengeCopy) : void
        {
            Cache.instance.copy.challengCopy.mopTower = param1.userObject as int;
            return;
        }// end function

        public function defenseCopyBuy(param1:int, param2:int) : void
        {
            rmi.iDefenseCopy.buy_async(new AMI_IDefenseCopy_buy(), param1, param2);
            return;
        }// end function

        public function defenseUse(param1:String, param2:int) : void
        {
            rmi.iDefenseCopy.use_async(new AMI_IDefenseCopy_use(), param1, param2, null);
            return;
        }// end function

        public function defenseCopyDress(param1:String, param2:String, param3:ItemData, param4:Point) : void
        {
            var defenseCopyDressSucceed:Function;
            var putOnUid:* = param1;
            var putOffUid:* = param2;
            var itemData:* = param3;
            var p:* = param4;
            defenseCopyDressSucceed = function (param1:AMI_IDefenseCopy_dress) : void
            {
                if (p)
                {
                    NetDispatcher.dispatchCmd(ServerCommand.DefenseCopyDressSucceed, {itemData:itemData, p:p});
                }
                return;
            }// end function
            ;
            rmi.iDefenseCopy.dress_async(new AMI_IDefenseCopy_dress(defenseCopyDressSucceed), putOnUid, putOffUid);
            return;
        }// end function

        public function defenseCopySell(param1:String) : void
        {
            rmi.iDefenseCopy.sell_async(new AMI_IDefenseCopy_sell(), param1);
            return;
        }// end function

        public function defenseTidy() : void
        {
            rmi.iDefenseCopy.tidy_async(new AMI_IDefenseCopy_tidy(this.defenseTidySuccess), new EPlayerItemPosType(EPlayerItemPosType._EPlayerItemPosTypeDefenseCopyBag));
            return;
        }// end function

        private function defenseTidySuccess(param1:AMI_IDefenseCopy_tidy, param2:Boolean) : void
        {
            if (param2)
            {
                MsgManager.showRollTipsMsg(Language.getString(20541));
            }
            else
            {
                MsgManager.showRollTipsMsg(Language.getString(20542));
            }
            return;
        }// end function

        public function defenseDiscard(param1:String) : void
        {
            rmi.iDefenseCopy.discard_async(new AMI_IDefenseCopy_discard(), param1);
            return;
        }// end function

        public function enterPetBreakCopy(param1:PetBreakCopyOperVo) : void
        {
            rmi.iCopy.enterPetBreakCopy_async(new AMI_ICopy_enterPetBreakCopy(), param1.floor, param1.level, param1.petUid);
            return;
        }// end function

        public function signUpArena(param1:int, param2:Boolean, param3:EArenaMode) : void
        {
            rmi.iCopy.signUpArena_async(new AMI_ICopy_signUpArena(), param1, param2, param3);
            return;
        }// end function

        public function enterArena(param1:SEntityId) : void
        {
            AIManager.cancelAll();
            rmi.iCopy.enterArena_async(new AMI_ICopy_enterArena(), param1);
            return;
        }// end function

        public function getMyArenaInfo(param1:int) : void
        {
            rmi.iCopy.getMyArenaInfo_async(new AMI_ICopy_getMyArenaInfo(), param1);
            return;
        }// end function

        public function getArenaBattles(param1:int) : void
        {
            rmi.iCopy.getArenaBattles_async(new AMI_ICopy_getArenaBattles(), param1);
            return;
        }// end function

        public function getArenaToplist(param1:int, param2:int) : void
        {
            var _loc_3:Object = {};
            _loc_3.copyType = param1;
            rmi.iCopy.getArenaToplist_async(new AMI_ICopy_getArenaToplist(this.getTopListSucc, null, _loc_3), param1, param2);
            return;
        }// end function

        private function getTopListSucc(param1:AMI_ICopy_getArenaToplist, param2:Array) : void
        {
            var _loc_3:* = param1.userObject;
            var _loc_4:* = _loc_3.copyType as int;
            if (_loc_4 == ECopyType._ECopyTypeArena)
            {
                NetDispatcher.dispatchCmd(ServerCommand.ArenaGetToplistInfo, param2);
            }
            else if (_loc_4 == ECopyType._ECopyTypeArena2v2)
            {
                NetDispatcher.dispatchCmd(ServerCommand.HeroArenaGetToplistInfo, param2);
            }
            return;
        }// end function

        public function enterArenaOB(param1:int, param2:int) : void
        {
            rmi.iCopy.enterArenaOB_async(new AMI_ICopy_enterArenaOB(), param1, param2);
            return;
        }// end function

        public function getArenaLevel() : void
        {
            rmi.iCopy.getArenaLv_async(new AMI_ICopy_getArenaLv(this.getLevelSucc));
            return;
        }// end function

        private function getLevelSucc(param1:AMI_ICopy_getArenaLv, param2:int) : void
        {
            ArenaController.ArenaLevel = param2;
            NetDispatcher.dispatchCmd(ServerCommand.ArenaUpdateArenaLevel, null);
            return;
        }// end function

        public function getArenaReward(param1:int, param2:int) : void
        {
            rmi.iCopy.getArenaReward_async(new AMI_ICopy_getArenaReward(), param1, param2);
            return;
        }// end function

        public function getArenaTeamAll(param1:int) : void
        {
            rmi.iHeroArena.getArenaTeamAll_async(new AMI_IArena2_getArenaTeamAll(), param1);
            return;
        }// end function

        public function getNoTeamPlayers() : void
        {
            rmi.iHeroArena.getNoTeamPlayers_async(new AMI_IArena2_getNoTeamPlayers());
            return;
        }// end function

        public function getArenaTeam(param1:SEntityId) : void
        {
            rmi.iHeroArena.getArenaTeam_async(new AMI_IArena2_getArenaTeam(), param1);
            return;
        }// end function

        public function createArenaTeam(param1:String) : void
        {
            rmi.iHeroArena.createArenaTeam_async(new AMI_IArena2_createArenaTeam(), param1);
            return;
        }// end function

        public function joinArenaTeam(param1:SEntityId) : void
        {
            rmi.iHeroArena.joinArenaTeam_async(new AMI_IArena2_joinArenaTeam(), param1);
            return;
        }// end function

        public function inviteArenaTeam(param1:SEntityId) : void
        {
            rmi.iHeroArena.inviteArenaTeam_async(new AMI_IArena2_inviteArenaTeam(), param1);
            return;
        }// end function

        public function quitArenaTeam() : void
        {
            rmi.iHeroArena.quitArenaTeam_async(new AMI_IArena2_quitArenaTeam());
            return;
        }// end function

        public function disbandArenaTeam() : void
        {
            rmi.iHeroArena.disbandArenaTeam_async(new AMI_IArena2_disbandArenaTeam());
            return;
        }// end function

        public function kickoutArenaTeam() : void
        {
            rmi.iHeroArena.kickoutArenaTeam_async(new AMI_IArena2_kickoutArenaTeam());
            return;
        }// end function

        public function changeCaptain() : void
        {
            rmi.iHeroArena.changeCaptain_async(new AMI_IArena2_changeCaptain());
            return;
        }// end function

        public function enterRestRoom() : void
        {
            rmi.iHeroArena.enterRestRoom_async(new AMI_IArena2_enterRestRoom());
            return;
        }// end function

        public function leftResetRoom() : void
        {
            rmi.iHeroArena.leftResetRoom_async(new AMI_IArena2_leftResetRoom());
            return;
        }// end function

        public function agreeInviteArenaTeam(param1:SEntityId) : void
        {
            rmi.iHeroArena.agreeInviteArenaTeam_async(new AMI_IArena2_agreeInviteArenaTeam(), param1);
            return;
        }// end function

        public function agreeJoinArenaTeam(param1:SEntityId) : void
        {
            rmi.iHeroArena.agreeJoinArenaTeam_async(new AMI_IArena2_agreeJoinArenaTeam(), param1);
            return;
        }// end function

        public function getDefenseDiscardInfo(param1:int) : void
        {
            var getDefenseInofSuss:Function;
            var copyCode:* = param1;
            getDefenseInofSuss = function (param1:AMI_IDefenseCopy_getDefenseRewardInfo, param2:SDefenseReward) : void
            {
                DefenseInfo.defenseInfo[copyCode] = param2;
                NetDispatcher.dispatchCmd(ServerCommand.CopyGroupGetDefenseInfoRes, null);
                return;
            }// end function
            ;
            rmi.iDefenseCopy.getDefenseRewardInfo_async(new AMI_IDefenseCopy_getDefenseRewardInfo(getDefenseInofSuss), copyCode);
            return;
        }// end function

        public function getDefenseDiscard(param1:int, param2:int) : void
        {
            var getDefenseRwSuccess:Function;
            var copyCode:* = param1;
            var wave:* = param2;
            getDefenseRwSuccess = function (param1:AMI_IDefenseCopy_getDefenseReward) : void
            {
                DefenseInfo.updateRwState(copyCode, wave, 2);
                NetDispatcher.dispatchCmd(ServerCommand.CopyGroupGetDefenseRwRes, null);
                return;
            }// end function
            ;
            rmi.iDefenseCopy.getDefenseReward_async(new AMI_IDefenseCopy_getDefenseReward(getDefenseRwSuccess), copyCode, wave);
            return;
        }// end function

        public function enterQuestionCopy() : void
        {
            AIManager.cancelAll();
            rmi.iCopy.enterQuestionCopy_async(new AMI_ICopy_enterQuestionCopy());
            return;
        }// end function

        public function getSunbathInfo() : void
        {
            rmi.iCopy.getSunbathInfo_async(new AMI_ICopy_getSunbathInfo());
            return;
        }// end function

        public function enterSunbath(param1:int) : void
        {
            AIManager.cancelAll();
            rmi.iCopy.enterSunbath_async(new AMI_ICopy_enterSunbath(), param1);
            return;
        }// end function

        public function sunbathOper(param1:int, param2:SEntityId) : void
        {
            rmi.iCopy.sunbathOper_async(new AMI_ICopy_sunbathOper(), param1, param2);
            return;
        }// end function

        public function getHeavenPlacardInfo() : void
        {
            rmi.iCopy.getHeavenPlacardInfo_async(new AMI_ICopy_getHeavenPlacardInfo(this.getHeavenInfoSucc));
            return;
        }// end function

        private function getHeavenInfoSucc(param1:AMI_ICopy_getHeavenPlacardInfo, param2:SPlacardMainInfo) : void
        {
            Cache.instance.tianDi.setMainInfo(1, param2);
            NetDispatcher.dispatchCmd(ServerCommand.TianDiRankGetDiMainInfo, null);
            return;
        }// end function

        public function getEarthPlacardInfo() : void
        {
            rmi.iCopy.getEarthPlacardInfo_async(new AMI_ICopy_getEarthPlacardInfo(this.getEarthInfoSucc));
            return;
        }// end function

        private function getEarthInfoSucc(param1:AMI_ICopy_getEarthPlacardInfo, param2:SPlacardMainInfo) : void
        {
            Cache.instance.tianDi.setMainInfo(0, param2);
            NetDispatcher.dispatchCmd(ServerCommand.TianDiRankGetDiMainInfo, null);
            return;
        }// end function

        public function getPlacardDetailInfo(param1:int) : void
        {
            rmi.iCopy.getPlacardDetailInfo_async(new AMI_ICopy_getPlacardDetailInfo(this.getDetailSucc), param1);
            return;
        }// end function

        private function getDetailSucc(param1:AMI_ICopy_getPlacardDetailInfo, param2:SPlacardDetailInfo) : void
        {
            Cache.instance.tianDi.setDetailInfo(param2);
            NetDispatcher.dispatchCmd(ServerCommand.TianDiRankGetPosDetail, null);
            return;
        }// end function

        public function enterPlacardCopy(param1:int) : void
        {
            rmi.iCopy.enterPlacardCopy_async(new AMI_ICopy_enterPlacardCopy(), param1);
            return;
        }// end function

        public function clearEnterCopyDiCd(param1:int, param2:int) : void
        {
            rmi.iCopy.clearEnterCopyCd_async(new AMI_ICopy_clearEnterCopyCd(this.clearEnterCopyDiCdSuccess, null, param1), param1, param2);
            return;
        }// end function

        private function clearEnterCopyDiCdSuccess(param1:AMI_ICopy_clearEnterCopyCd) : void
        {
            if (param1.userObject == GameConst.UniqueBossCopyCode)
            {
                NetDispatcher.dispatchCmd(ServerCommand.UniqueBossClearCdSucc, null);
            }
            else
            {
                if (Cache.instance.tianDi.cdCkIndex == 0)
                {
                    Cache.instance.tianDi.selfCdTime = 0;
                }
                else
                {
                    Cache.instance.tianDi.tianSelfCdTime = 0;
                }
                Cache.instance.tianDi.cdCkIndex = 0;
                NetDispatcher.dispatchCmd(ServerCommand.TianDiRankClearCopyCDSucc, null);
            }
            return;
        }// end function

        public function enterWinePartyCopy() : void
        {
            AIManager.cancelAll();
            rmi.iCopy.enterGuildWinePartyCopy_async(new AMI_ICopy_enterGuildWinePartyCopy());
            return;
        }// end function

        public function enterZZXYBattleCopy(param1:int = 1) : void
        {
            rmi.iCopy.enterPeaceBossCopy_async(new AMI_ICopy_enterPeaceBossCopy(), param1);
            return;
        }// end function

        public function zzxyBattleGetRoomList() : void
        {
            rmi.iCopy.getPeaceBossRoomList_async(new AMI_ICopy_getPeaceBossRoomList());
            return;
        }// end function

        public function enterTreasureHuntCopy() : void
        {
            rmi.iCopy.enterRaidersCopy_async(new AMI_ICopy_enterRaidersCopy());
            return;
        }// end function

        public function enterGuildDefenseCopy(param1:int) : void
        {
            AIManager.cancelAll();
            rmi.iCopy.enterGuildDefenseCopy_async(new AMI_ICopy_enterGuildDefenseCopy(), param1);
            return;
        }// end function

        public function upgradeTower(param1:int, param2:int) : void
        {
            rmi.iCopy.upgradeGuildDefenseCopyTower_async(new AMI_ICopy_upgradeGuildDefenseCopyTower(), param1, param2);
            return;
        }// end function

        public function enterMonsterSiege() : void
        {
            rmi.iCopy.enterMonsterSiege_async(new AMI_ICopy_enterMonsterSiege());
            return;
        }// end function

        public function changeBoss(param1:SEntityId) : void
        {
            rmi.iCopy.changeBoss_async(new AMI_ICopy_changeBoss(), param1);
            return;
        }// end function

        public function getUniqueBossCopyPanelInfo(param1:int) : void
        {
            rmi.iCopy.getUniqueBossCopyPanelInfo_async(new AMI_ICopy_getUniqueBossCopyPanelInfo(this.getInfoSucc), param1);
            return;
        }// end function

        private function getInfoSucc(param1:AMI_ICopy_getUniqueBossCopyPanelInfo, param2:SUniquePanelInfo) : void
        {
            NetDispatcher.dispatchCmd(ServerCommand.UniqueBossGetBossInfo, param2);
            return;
        }// end function

        public function getUniqueBossHurtListInfo(param1:Function, param2:Function) : void
        {
            rmi.iCopy.getUniqueBossHurtList_async(new AMI_ICopy_getUniqueBossHurtList(param1, param2));
            return;
        }// end function

        public function rentGuildMercenary(param1:int, param2:int) : void
        {
            rmi.iCopy.rentGuildMercenary_async(new AMI_ICopy_rentGuildMercenary(), param1, param2);
            return;
        }// end function

        public function enterTowerCopy4(param1:int, param2:int) : void
        {
            rmi.iCopy.enterTowerCopy4_async(new AMI_ICopy_enterTowerCopy4(), param1, param2);
            return;
        }// end function

        public function goToTowerCopy4Level(param1:int, param2:int) : void
        {
            rmi.iCopy.goToTowerCopy4Level_async(new AMI_ICopy_goToTowerCopy4Level(), param1, param2);
            return;
        }// end function

        private function singleEnterSuccess(param1:AMI_ICopy_goToTowerCopy4Level) : void
        {
            return;
        }// end function

        public function getTowerCopy4FirstRewardGetInfo(param1:int) : void
        {
            this._frInfoCode = param1;
            rmi.iCopy.getTowerCopy4FirstRewardGetInfo_async(new AMI_ICopy_getTowerCopy4FirstRewardGetInfo(this.singleGetFirstInfoSuccess), param1);
            return;
        }// end function

        private function singleGetFirstInfoSuccess(param1:AMI_ICopy_getTowerCopy4FirstRewardGetInfo, param2:Dictionary) : void
        {
            Cache.instance.copy.groupTower.initSingleFtRw(this._frInfoCode, param2);
            NetDispatcher.dispatchCmd(ServerCommand.SingleTowerCopyGetFtRwInfoRes, null);
            return;
        }// end function

        public function getTowerCopy4FirstReward(param1:int, param2:int) : void
        {
            this._getRwCode = param1;
            this._getRwLevel = param2;
            rmi.iCopy.getTowerCopy4FirstRewards_async(new AMI_ICopy_getTowerCopy4FirstRewards(this.singleGetFirstRewardSuccess), param1, param2);
            return;
        }// end function

        private function singleGetFirstRewardSuccess(param1:AMI_ICopy_getTowerCopy4FirstRewards) : void
        {
            Cache.instance.copy.groupTower.updateFirstRwState(this._getRwCode, this._getRwLevel);
            NetDispatcher.dispatchCmd(ServerCommand.SingleTowerCopyGetFtRes, {code:this._getRwCode, lv:this._getRwLevel});
            return;
        }// end function

        public function enterCrossMainCityKOBattle() : void
        {
            rmi.iCopy.enterMainCityBattle_async(new AMI_ICopy_enterMainCityBattle());
            return;
        }// end function

        public function enterCrossMainCity() : void
        {
            rmi.iCopy.enterCrossMainCity_async(new AMI_ICopy_enterCrossMainCity());
            return;
        }// end function

        public function enterCrossMainCityFinalBattle() : void
        {
            rmi.iCopy.enterMainCityBattle2Copy_async(new AMI_ICopy_enterMainCityBattle2Copy());
            return;
        }// end function

        public function crossMainCityGetFinalRank() : void
        {
            rmi.iCopy.getMainCityBattle2Details_async(new AMI_ICopy_getMainCityBattle2Details());
            return;
        }// end function

        public function crossMainCityGetKORank() : void
        {
            rmi.iCopy.getMainCityBattle1Details_async(new AMI_ICopy_getMainCityBattle1Details());
            return;
        }// end function

        public function enterExpCopy() : void
        {
            rmi.iCopy.enterExpCopy_async(new AMI_ICopy_enterExpCopy());
            return;
        }// end function

        public function addCopyNum(param1:int) : void
        {
            rmi.iCopy.addCopyNum_async(new AMI_ICopy_addCopyNum(), param1);
            return;
        }// end function

    }
}
